---

Solidity Gas Optimization Techniques

---

1. Storage Optimization

• Key Insight: Storing data on-chain is expensive. Use efficient techniques to reduce storage costs.
• Cost Breakdown:
  • Storing a new variable: 20,000 gas
  • Rewriting an existing variable: 5,000 gas
  • Reading from storage: 200 gas

Code Example:

contract GasOptimization {
    // Storage variable declaration (no initialization cost)
    uint256 public storedData;

    // Efficient data management
    function updateData(uint256 newValue) external {
        uint256 memoryData = newValue; // Use memory for calculations
        storedData = memoryData; // Update storage once
    }
}

Techniques:

• Minimize on-chain data: Store only essential information on-chain.
• Efficient data management: Calculate values in memory before writing to storage.
• Variable Packing: Pack smaller data types into a single storage slot.

Code Example - Variable Packing:

struct PackedData {
    uint8 data1;
    uint8 data2;
}
PackedData public packedData;

---

2. Gas Refund Mechanisms

• Freeing Storage Slots: Zeroing out unused storage slots can refund 15,000 gas.
• Self Destruct: Use selfdestruct to refund 24,000 gas by removing the contract.

Code Example:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.18;

contract GasRefundExample {
    uint256 public value1;
    uint256 public value2;

    function updateValuesAndFreeStorageSlot(uint256 _newValue1, uint256 _newValue2) external {
        value1 = _newValue1;
        value2 = _newValue2;
        assembly {
            sstore(value1.slot, 0)
            sstore(value2.slot, 0)
        }
    }

    function destroyContract() external {
        selfdestruct(payable(msg.sender));
    }
}

---

3. Data Types and Packing

• Use bytes32 when possible: More gas-efficient for storing fixed-size data.
• Avoid packing in memory or function calls: No gas savings here, as the EVM operates on 32-byte words.

Code Example:

contract VariablePacking {
    bytes32 public fixedSizeData;

    // Using bytes32 is cheaper than string
    function setData(bytes32 _data) external {
        fixedSizeData = _data;
    }
}

---

4. Inheritance vs Composition

• Use Inheritance: More gas-efficient as variables from parent contracts are packed efficiently.

Code Example:

contract Parent {
    uint256 public parentVar;

    constructor(uint256 _parentVar) {
        parentVar = _parentVar;
    }
}

contract Child is Parent {
    uint256 public childVar;

    constructor(uint256 _parentVar, uint256 _childVar) Parent(_parentVar) {
        childVar = _childVar;
    }
}

---

5. Memory vs Storage

• Use storage pointers to avoid expensive copying between memory and storage.
• Memory costs are complicated: Memory allocation grows quadratically, so manage it wisely.

Code Example:

function sumValues(uint256[] memory values) external pure returns (uint256) {
    uint256 sum;
    for (uint256 i = 0; i < values.length; i++) {
        sum += values[i];
    }
    return sum;
}

---

6. Mappings vs Arrays

• Use Mappings: More gas-efficient for large datasets.
• Use Arrays: Better for small datasets or when iteration is necessary.

Code Example:

mapping(address => uint256) public balances;

function updateBalance(address user, uint256 amount) external {
    balances[user] = amount;
}

---

7. Variable Optimization

• Avoid public variables: Use private to save gas.
• Use events for data logging instead of storing data directly in the contract.

Code Example:

contract EfficientVariables {
    uint256 private myPrivateVar;

    event ValueUpdated(uint256 newValue);

    function updatePrivateVar(uint256 newValue) external {
        myPrivateVar = newValue;
        emit ValueUpdated(newValue);
    }
}

---

8. Function Optimization

• Use external functions: More gas-efficient than public functions.
• Optimize frequently-called functions by placing them earlier in the contract.

Code Example:

contract FunctionOptimization {
    address public owner;

    constructor() {
        owner = msg.sender;
    }

    function getDataExternal() external view returns (uint256) {
        return 42;
    }

    function frequentlyCalledFunction() external pure returns (string memory) {
        return "Hello!";
    }
}

---

Conclusion

By incorporating gas optimization techniques like minimizing storage use, careful handling of memory, leveraging inheritance, and proper data type selection, Solidity developers can significantly reduce gas costs and improve contract efficiency.

---